Please address the comments from this code review:

## Overall Comments
- The `_qqofficial_retry` decorator comment mentions HTTP 429 but the retry condition only targets `ServerError` and `SequenceNumberError`; consider either adding the 429-related exception type or updating the comment to reflect the actual behavior.
- Both `_do_upload` inner functions are redefined on each call; if this pattern is used elsewhere or grows, consider extracting a shared helper that takes the route/payload to avoid per-call function creation and keep retry usage consistent.
- The log message `上传媒体文件失败，已重试3次` hardcodes the retry count; it would be more maintainable to derive this from the `stop_after_attempt` configuration or a shared constant so logs stay accurate if the retry policy changes.

## Individual Comments

### Comment 1
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="55-64" />
<code_context>

 _patch_qq_botpy_formdata()

+# Retry decorator for QQ Official API transient errors (HTTP 500/504, 429)
+_qqofficial_retry = retry(
+    retry=retry_if_exception_type(
+        (
+            botpy.errors.ServerError,
+            botpy.errors.SequenceNumberError,
+        )
+    ),
+    stop=stop_after_attempt(3),
+    wait=wait_exponential(multiplier=1, min=1, max=10),
+    before_sleep=before_sleep_log(logger, logging.WARNING),
+    reraise=True,
+)
+
</code_context>
<issue_to_address>
**issue (bug_risk):** The retry decorator comment mentions HTTP 429, but the retry condition only covers specific exception types, which might not include 429 responses.

The decorator comment implies we generically handle HTTP 500/504 and 429, but the predicate only retries `ServerError` and `SequenceNumberError`. If 429 is represented by a different exception type in `botpy`, those cases won’t be retried as the comment suggests. Please either (a) adjust the comment to match the actual retried exceptions, or (b) expand the predicate to include the 429-specific exception type, if one exists in `botpy`.
</issue_to_address>

### Comment 2
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="566-567" />
<code_context>
                     file_info=result["file_info"],
                     ttl=result.get("ttl", 0),
                 )
+        except (botpy.errors.ServerError, botpy.errors.SequenceNumberError):
+            logger.error(f"上传媒体文件失败，已重试3次: {file_source}")
         except Exception as e:
             logger.error(f"上传请求错误: {e}")
</code_context>
<issue_to_address>
**nitpick:** The log message about the number of retries may not match the actual number of attempts configured in the retry policy.

With `stop_after_attempt(3)`, tenacity makes at most 3 total attempts (1 initial + 2 retries). The text `"已重试3次"` suggests 3 retries after the first attempt, which can be misleading when debugging. Consider updating the message to clearly distinguish total attempts vs retries, or derive the number from the retry configuration instead of hardcoding it.
</issue_to_address>

### Comment 3
<location path="astrbot/core/platform/sources/qqofficial/qqofficial_message_event.py" line_range="478" />
<code_context>
-            result = await self.bot.api._http.request(route, json=payload)
-        else:
-            raise ValueError("Invalid upload parameters")
+        @_qqofficial_retry
+        async def _do_upload():
+            if "openid" in kwargs:
</code_context>
<issue_to_address>
**issue (complexity):** Consider extracting a shared retried HTTP helper method and using it from both upload functions to avoid nested functions and duplicated retry logic.

You can keep the retry behavior while reducing nesting and duplication by extracting a small shared helper and moving retry to that layer instead of per‑call inner functions.

### 1. Centralize the retried HTTP call

Define a single retried helper on the class and use it in both methods:

```python
# keep your existing decorator definition
_qqofficial_retry = retry(
    retry=retry_if_exception_type(
        (
            botpy.errors.ServerError,
            botpy.errors.SequenceNumberError,
        )
    ),
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=1, max=10),
    before_sleep=before_sleep_log(logger, logging.WARNING),
    reraise=True,
)


class QQOfficialMessageEvent(AstrMessageEvent):
    ...

    @_qqofficial_retry
    async def _request_with_retry(self, route: Route, payload: dict):
        return await self.bot.api._http.request(route, json=payload)
```

### 2. Flatten `upload_group_and_c2c_image`

Remove the inner function, keep routing/validation in the main function, and delegate only the HTTP request to the retried helper:

```python
    async def upload_group_and_c2c_image(
        self,
        image_base64: str,
        file_type: int,
        **kwargs,
    ) -> botpy.types.message.Media:
        payload = {
            "file_data": image_base64,
            "file_type": file_type,
            "srv_send_msg": False,
        }

        if "openid" in kwargs:
            payload["openid"] = kwargs["openid"]
            route = Route("POST", "/v2/users/{openid}/files", openid=kwargs["openid"])
        elif "group_openid" in kwargs:
            payload["group_openid"] = kwargs["group_openid"]
            route = Route(
                "POST",
                "/v2/groups/{group_openid}/files",
                group_openid=kwargs["group_openid"],
            )
        else:
            raise ValueError("Invalid upload parameters")

        result = await self._request_with_retry(route, payload)

        if not isinstance(result, dict):
            raise RuntimeError(
                f"Failed to upload image, response is not dict: {result}"
            )

        return Media(
            file_uuid=result["file_uuid"],
            file_info=result["file_info"],
            ttl=result.get("ttl", 0),
        )
```

This keeps the same retry semantics but removes the extra nested async function and makes the boundary between parameter routing and HTTP I/O clearer.

### 3. Simplify `upload_group_and_c2c_media` and centralize logging

Use the same helper and reduce duplicated exception handling around the same error types:

```python
    async def upload_group_and_c2c_media(
        self,
        file_source: str,
        file_type: int,
        srv_send_msg: bool = False,
        file_name: str | None = None,
        **kwargs,
    ) -> Media | None:
        payload: dict = {"file_type": file_type, "srv_send_msg": srv_send_msg}
        if file_name:
            payload["file_name"] = file_name

        if os.path.exists(file_source):
            async with aiofiles.open(file_source, "rb") as f:
                file_content = await f.read()
            payload["file_data"] = base64.b64encode(file_content).decode("utf-8")
        else:
            payload["file_data"] = await file_to_base64(file_source)

        if "openid" in kwargs:
            payload["openid"] = kwargs["openid"]
            route = Route("POST", "/v2/users/{openid}/files", openid=kwargs["openid"])
        elif "group_openid" in kwargs:
            payload["group_openid"] = kwargs["group_openid"]
            route = Route(
                "POST",
                "/v2/groups/{group_openid}/files",
                group_openid=kwargs["group_openid"],
            )
        else:
            return None

        try:
            result = await self._request_with_retry(route, payload)

            if result:
                if not isinstance(result, dict):
                    logger.error(f"上传文件响应格式错误: {result}")
                    return None

                return Media(
                    file_uuid=result["file_uuid"],
                    file_info=result["file_info"],
                    ttl=result.get("ttl", 0),
                )
        except botpy.errors.ServerError | botpy.errors.SequenceNumberError:
            logger.error(f"上传媒体文件失败，已重试3次: {file_source}")
        except Exception as e:
            logger.error(f"上传请求错误: {e}")

        return None
```

Key points:

- Retry logic is applied once in `_request_with_retry`, avoiding per‑call inner functions and duplicated decorator usage.
- Routing and argument validation stay in the public methods, making it clearer what is retryable vs. parameter errors.
- Logging for final failure of retryable errors is localized in one place per method, without re‑encoding the same error list in both the decorator and inner function.
</issue_to_address>